home *** CD-ROM | disk | FTP | other *** search
/ IRIX 6.3 Development Libraries / SGI IRIX 6.3 Development Libraries.iso / dist6.3 / gl_dev.idb / usr / lib / lint / llib-lgl.z / llib-lgl
Encoding:
Text File  |  1996-12-06  |  23.7 KB  |  1,724 lines
  1. /*
  2.  * llib-lgl.c - lint library source for the GL
  3.  */
  4.  
  5. #include <gl/gl.h>
  6.  
  7. /*LINTLIBRARY*/
  8. long gversion(char v[12])
  9. {
  10.     return (long)0;
  11. }
  12.  
  13. void pagecolor(Colorindex c)
  14. {}
  15.  
  16. void textcolor(Colorindex c)
  17. {}
  18.  
  19. void textport(Screencoord left, Screencoord right, Screencoord bottom, Screencoord top)
  20. {}
  21.  
  22. void arc(Coord x, Coord y, Coord radius, Angle startang, Angle endang)
  23. {}
  24.  
  25. void arcf(Coord x, Coord y, Coord radius, Angle startang, Angle endang)
  26. {}
  27.  
  28. void arcfi(Icoord x, Icoord y, Icoord radius, Angle startang, Angle endang)
  29. {}
  30.  
  31. void arci(Icoord x, Icoord y, Icoord radius, Angle startang, Angle endang)
  32. {}
  33.  
  34. void attachcursor(Device vx, Device vy)
  35. {}
  36.  
  37. void backbuffer(Boolean b)
  38. {}
  39.  
  40. void bbox2(Screencoord xmin, Screencoord ymin, Coord x1, Coord y1, Coord x2, Coord y2)
  41. {}
  42.  
  43. void bbox2i(Screencoord xmin, Screencoord ymin, Icoord x1, Icoord y1, Icoord x2, Icoord y2)
  44. {}
  45.  
  46. void blink(short rate, Colorindex c, short red, short green, short blue)
  47. {}
  48.  
  49. void callobj(Object obj)
  50. {}
  51.  
  52. void charstr(String str)
  53. {}
  54.  
  55. void circ(Coord x, Coord y, Coord radius)
  56. {}
  57.  
  58. void circf(Coord x, Coord y, Coord radius)
  59. {}
  60.  
  61. void circfi(Icoord x, Icoord y, Icoord radius)
  62. {}
  63.  
  64. void circi(Icoord x, Icoord y, Icoord radius)
  65. {}
  66.  
  67. void clear(void)
  68. {}
  69.  
  70. void clearhitcode(void)
  71. {}
  72.  
  73. void closeobj(void)
  74. {}
  75.  
  76. void cmov(Coord x, Coord y, Coord z)
  77. {}
  78.  
  79. void cmov2(Coord x, Coord y)
  80. {}
  81.  
  82. void cmov2i(Icoord x, Icoord y)
  83. {}
  84.  
  85. void cmovi(Icoord x, Icoord y, Icoord z)
  86. {}
  87.  
  88. void color(Colorindex c)
  89. {}
  90.  
  91. void cursoff(void)
  92. {}
  93.  
  94. void curson(void)
  95. {}
  96.  
  97. void curveit(short iterationcount)
  98. {}
  99.  
  100. void defcursor(short n, const unsigned short curs[128])
  101. {}
  102.  
  103. void deflinestyle(short n, Linestyle ls)
  104. {}
  105.  
  106. void defrasterfont(short n, short ht, short nc, const Fontchar chars[], short nr, const unsigned short raster[])
  107. {}
  108.  
  109. void delobj(Object obj)
  110. {}
  111.  
  112. void doublebuffer(void)
  113. {}
  114.  
  115. void draw(Coord x, Coord y, Coord z)
  116. {}
  117.  
  118. void draw2(Coord x, Coord y)
  119. {}
  120.  
  121. void draw2i(Icoord x, Icoord y)
  122. {}
  123.  
  124. void drawi(Icoord x, Icoord y, Icoord z)
  125. {}
  126.  
  127. void editobj(Object obj)
  128. {}
  129.  
  130. long endpick(short buffer[])
  131. {
  132.     return (long)0;
  133. }
  134.  
  135. long endselect(short buffer[])
  136. {
  137.     return (long)0;
  138. }
  139.  
  140. void finish(void)
  141. {}
  142.  
  143. void font(short fntnum)
  144. {}
  145.  
  146. void frontbuffer(Boolean b)
  147. {}
  148.  
  149. void gconfig(void)
  150. {}
  151.  
  152. Object genobj(void)
  153. {
  154.     return (Object)0;
  155. }
  156.  
  157. Tag gentag(void)
  158. {
  159.     return (Tag)0;
  160. }
  161.  
  162. long getbuffer(void)
  163. {
  164.     return (long)0;
  165. }
  166.  
  167. Boolean getbutton(Device num)
  168. {
  169.     return (Boolean)0;
  170. }
  171.  
  172. Boolean getcmmode(void)
  173. {
  174.     return (Boolean)0;
  175. }
  176.  
  177. long getcolor(void)
  178. {
  179.     return (long)0;
  180. }
  181.  
  182. void getcursor(short *index, Colorindex *c, Colorindex *wtm, Boolean *b)
  183. {}
  184.  
  185. void getdepth(Screencoord *znear, Screencoord *zfar)
  186. {}
  187.  
  188. long getdisplaymode(void)
  189. {
  190.     return (long)0;
  191. }
  192.  
  193. long getfont(void)
  194. {
  195.     return (long)0;
  196. }
  197.  
  198. long getheight(void)
  199. {
  200.     return (long)0;
  201. }
  202.  
  203. long gethitcode(void)
  204. {
  205.     return (long)0;
  206. }
  207.  
  208. Boolean getlsbackup(void)
  209. {
  210.     return (Boolean)0;
  211. }
  212.  
  213. long getlstyle(void)
  214. {
  215.     return (long)0;
  216. }
  217.  
  218. long getlwidth(void)
  219. {
  220.     return (long)0;
  221. }
  222.  
  223. long getmap(void)
  224. {
  225.     return (long)0;
  226. }
  227.  
  228. void getmatrix(Matrix m)
  229. {}
  230.  
  231. long getplanes(void)
  232. {
  233.     return (long)0;
  234. }
  235.  
  236. Boolean getresetls(void)
  237. {
  238.     return (Boolean)0;
  239. }
  240.  
  241. void getscrmask(Screencoord *left, Screencoord *right, Screencoord *bottom, Screencoord *top)
  242. {}
  243.  
  244. long getvaluator(Device val)
  245. {
  246.     return (long)0;
  247. }
  248.  
  249. void getviewport(Screencoord *left, Screencoord *right, Screencoord *bottom, Screencoord *top)
  250. {}
  251.  
  252. long getwritemask(void)
  253. {
  254.     return (long)0;
  255. }
  256.  
  257. void gflush(void)
  258. {}
  259.  
  260. void ginit(void)
  261. {}
  262.  
  263. void greset(void)
  264. {}
  265.  
  266. void gRGBcolor(short *red, short *green, short *blue)
  267. {}
  268.  
  269. void gRGBcursor(short *index, short *red, short *green, short *blue, short *redm, short *greenm, short *bluem, Boolean *b)
  270. {}
  271.  
  272. void gRGBmask(short *redm, short *greenm, short *bluem)
  273. {}
  274.  
  275. Boolean isobj(Object obj)
  276. {
  277.     return (Boolean)0;
  278. }
  279.  
  280. Boolean istag(Tag t)
  281. {
  282.     return (Boolean)0;
  283. }
  284.  
  285. void linewidth(short n)
  286. {}
  287.  
  288. void loadmatrix(const Matrix m)
  289. {}
  290.  
  291. void lookat(Coord vx, Coord vy, Coord vz, Coord px, Coord py, Coord pz, Angle twist)
  292. {}
  293.  
  294. void lsbackup(Boolean b)
  295. {}
  296.  
  297. void makeobj(Object obj)
  298. {}
  299.  
  300. void maketag(Tag t)
  301. {}
  302.  
  303. void mapcolor(Colorindex c, short red, short green, short blue)
  304. {}
  305.  
  306. void mapw(Object vobj, Screencoord sx, Screencoord sy, Coord *wx1, Coord *wy1, Coord *wz1, Coord *wx2, Coord *wy2, Coord *wz2)
  307. {}
  308.  
  309. void mapw2(Object vobj, Screencoord sx, Screencoord sy, Coord *wx, Coord *wy)
  310. {}
  311.  
  312. void move(Coord x, Coord y, Coord z)
  313. {}
  314.  
  315. void move2(Coord x, Coord y)
  316. {}
  317.  
  318. void move2i(Icoord x, Icoord y)
  319. {}
  320.  
  321. void movei(Icoord x, Icoord y, Icoord z)
  322. {}
  323.  
  324. void multimap(void)
  325. {}
  326.  
  327. void multmatrix(const Matrix m)
  328. {}
  329.  
  330. void noise(Device v, short delta)
  331. {}
  332.  
  333. void onemap(void)
  334. {}
  335.  
  336. void ortho(Coord left, Coord right, Coord bottom, Coord top, Coord znear, Coord zfar)
  337. {}
  338.  
  339. void ortho2(Coord left, Coord right, Coord bottom, Coord top)
  340. {}
  341.  
  342. void perspective(Angle fovy, float aspect, Coord znear, Coord zfar)
  343. {}
  344.  
  345. void pick(short buffer[], long numnames)
  346. {}
  347.  
  348. void picksize(short deltax, short deltay)
  349. {}
  350.  
  351. void pnt(Coord x, Coord y, Coord z)
  352. {}
  353.  
  354. void pnt2(Coord x, Coord y)
  355. {}
  356.  
  357. void pnt2i(Icoord x, Icoord y)
  358. {}
  359.  
  360. void pnti(Icoord x, Icoord y, Icoord z)
  361. {}
  362.  
  363. void polarview(Coord dist, Angle azim, Angle inc, Angle twist)
  364. {}
  365.  
  366. void polf(long n, const Coord parray[][3])
  367. {}
  368.  
  369. void polf2(long n, const Coord parray[][2])
  370. {}
  371.  
  372. void polf2i(long n, const Icoord parray[][2])
  373. {}
  374.  
  375. void polfi(long n, const Icoord parray[][3])
  376. {}
  377.  
  378. void poly(long n, const Coord parray[][3])
  379. {}
  380.  
  381. void poly2(long n, const Coord parray[][2])
  382. {}
  383.  
  384. void poly2i(long n, const Icoord parray[][2])
  385. {}
  386.  
  387. void polyi(long n, const Icoord parray[][3])
  388. {}
  389.  
  390. void popattributes(void)
  391. {}
  392.  
  393. void popmatrix(void)
  394. {}
  395.  
  396. void popviewport(void)
  397. {}
  398.  
  399. void pushattributes(void)
  400. {}
  401.  
  402. void pushmatrix(void)
  403. {}
  404.  
  405. void pushviewport(void)
  406. {}
  407.  
  408. void qenter(Device qtype, short val)
  409. {}
  410.  
  411. long qread(short *data)
  412. {
  413.     return (long)0;
  414. }
  415.  
  416. void qreset(void)
  417. {}
  418.  
  419. long qtest(void)
  420. {
  421.     return (long)0;
  422. }
  423.  
  424. long readpixels(short n, Colorindex colors[])
  425. {
  426.     return (long)0;
  427. }
  428.  
  429. long readRGB(short n, RGBvalue red[], RGBvalue green[], RGBvalue blue[])
  430. {
  431.     return (long)0;
  432. }
  433.  
  434. void rect(Coord x1, Coord y1, Coord x2, Coord y2)
  435. {}
  436.  
  437. void rectf(Coord x1, Coord y1, Coord x2, Coord y2)
  438. {}
  439.  
  440. void rectfi(Icoord x1, Icoord y1, Icoord x2, Icoord y2)
  441. {}
  442.  
  443. void recti(Icoord x1, Icoord y1, Icoord x2, Icoord y2)
  444. {}
  445.  
  446. void resetls(Boolean b)
  447. {}
  448.  
  449. void RGBcolor(short red, short green, short blue)
  450. {}
  451.  
  452. void RGBcursor(short index, short red, short green, short blue, short redm, short greenm, short bluem)
  453. {}
  454.  
  455. void RGBmode(void)
  456. {}
  457.  
  458. void RGBwritemask(short red, short green, short blue)
  459. {}
  460.  
  461. void rotate(Angle a, char axis)
  462. {}
  463.  
  464. void scale(float x, float y, float z)
  465. {}
  466.  
  467. void scrmask(Screencoord left, Screencoord right, Screencoord bottom, Screencoord top)
  468. {}
  469.  
  470. void gselect(short buffer[], long numnames)
  471. {}
  472.  
  473. void setcursor(short index, Colorindex c, Colorindex wtm)
  474. {}
  475.  
  476. void setdepth(Screencoord znear, Screencoord zfar)
  477. {}
  478.  
  479. void setlinestyle(short index)
  480. {}
  481.  
  482. void setmap(short mapnum)
  483. {}
  484.  
  485. void setvaluator(Device v, short init, short vmin, short vmax)
  486. {}
  487.  
  488. void singlebuffer(void)
  489. {}
  490.  
  491. long strwidth(String str)
  492. {
  493.     return (long)0;
  494. }
  495.  
  496. void swapbuffers(void)
  497. {}
  498.  
  499. void swapinterval(short i)
  500. {}
  501.  
  502. void gsync(void)
  503. {}
  504.  
  505. void tie(Device b, Device v1, Device v2)
  506. {}
  507.  
  508. void translate(Coord x, Coord y, Coord z)
  509. {}
  510.  
  511. void viewport(Screencoord left, Screencoord right, Screencoord bottom, Screencoord top)
  512. {}
  513.  
  514. void window(Coord left, Coord right, Coord bottom, Coord top, Coord znear, Coord zfar)
  515. {}
  516.  
  517. void writemask(Colorindex wtm)
  518. {}
  519.  
  520. void writepixels(short n, const Colorindex colors[])
  521. {}
  522.  
  523. void writeRGB(short n, const RGBvalue red[], const RGBvalue green[], const RGBvalue blue[])
  524. {}
  525.  
  526. void tpon(void)
  527. {}
  528.  
  529. void tpoff(void)
  530. {}
  531.  
  532. void gexit(void)
  533. {}
  534.  
  535. void clkon(void)
  536. {}
  537.  
  538. void clkoff(void)
  539. {}
  540.  
  541. void lampon(Byte lamps)
  542. {}
  543.  
  544. void lampoff(Byte lamps)
  545. {}
  546.  
  547. void setbell(Byte mode)
  548. {}
  549.  
  550. void ringbell(void)
  551. {}
  552.  
  553. void arcfs(Scoord x, Scoord y, Scoord radius, Angle startang, Angle endang)
  554. {}
  555.  
  556. void arcs(Scoord x, Scoord y, Scoord radius, Angle startang, Angle endang)
  557. {}
  558.  
  559. void bbox2s(Screencoord xmin, Screencoord ymin, Scoord x1, Scoord y1, Scoord x2, Scoord y2)
  560. {}
  561.  
  562. void blankscreen(Boolean bool)
  563. {}
  564.  
  565. long blkqread(short data[], short n)
  566. {
  567.     return (long)0;
  568. }
  569.  
  570. void getmcolor(Colorindex c, short *r, short *g, short *b)
  571. {}
  572.  
  573. void chunksize(long chunk)
  574. {}
  575.  
  576. void circfs(Scoord x, Scoord y, Scoord radius)
  577. {}
  578.  
  579. void circs(Scoord x, Scoord y, Scoord radius)
  580. {}
  581.  
  582. void cmov2s(Scoord x, Scoord y)
  583. {}
  584.  
  585. void cmovs(Scoord x, Scoord y, Scoord z)
  586. {}
  587.  
  588. void compactify(Object obj)
  589. {}
  590.  
  591. void qdevice(Device v)
  592. {}
  593.  
  594. void unqdevice(Device v)
  595. {}
  596.  
  597. void curvebasis(short basisid)
  598. {}
  599.  
  600. void curveprecision(short nsegments)
  601. {}
  602.  
  603. void crv(const Coord geom[4][3])
  604. {}
  605.  
  606. void gbegin(void)
  607. {}
  608.  
  609. void textinit(void)
  610. {}
  611.  
  612. void crvn(long n, const Coord geom[][3])
  613. {}
  614.  
  615. void defbasis(short id, const Matrix mat)
  616. {}
  617.  
  618. void deltag(Tag t)
  619. {}
  620.  
  621. void depthcue(Boolean mode)
  622. {}
  623.  
  624. void draw2s(Scoord x, Scoord y)
  625. {}
  626.  
  627. void draws(Scoord x, Scoord y, Scoord z)
  628. {}
  629.  
  630. long endfeedback(void *buffer)
  631. {
  632.     return (long)0;
  633. }
  634.  
  635. void feedback(void *buffer, long size)
  636. {}
  637.  
  638. void getcpos(short *ix, short *iy)
  639. {}
  640.  
  641. Boolean getdcm(void)
  642. {
  643.     return (Boolean)0;
  644. }
  645.  
  646. void getgpos(Coord *fx, Coord *fy, Coord *fz, Coord *fw)
  647. {}
  648.  
  649. long getlsrepeat(void)
  650. {
  651.     return (long)0;
  652. }
  653.  
  654. long getmonitor(void)
  655. {
  656.     return (long)0;
  657. }
  658.  
  659. Object getopenobj(void)
  660. {
  661.     return (Object)0;
  662. }
  663.  
  664. Boolean getzbuffer(void)
  665. {
  666.     return (Boolean)0;
  667. }
  668.  
  669. void initnames(void)
  670. {}
  671.  
  672. void loadname(short name)
  673. {}
  674.  
  675. void lsrepeat(long factor)
  676. {}
  677.  
  678. void move2s(Scoord x, Scoord y)
  679. {}
  680.  
  681. void moves(Scoord x, Scoord y, Scoord z)
  682. {}
  683.  
  684. void newtag(Tag newtg, Tag oldtg, Offset offst)
  685. {}
  686.  
  687. void passthrough(short token)
  688. {}
  689.  
  690. void patchbasis(long uid, long vid)
  691. {}
  692.  
  693. void patchprecision(long usegments, long vsegments)
  694. {}
  695.  
  696. void patch(const Matrix geomx, const Matrix geomy, const Matrix geomz)
  697. {}
  698.  
  699. void pclos(void)
  700. {}
  701.  
  702. void pdr(Coord x, Coord y, Coord z)
  703. {}
  704.  
  705. void pdr2(Coord x, Coord y)
  706. {}
  707.  
  708. void pdri(Icoord x, Icoord y, Icoord z)
  709. {}
  710.  
  711. void pdr2i(Icoord x, Icoord y)
  712. {}
  713.  
  714. void pdrs(Scoord x, Scoord y, Scoord z)
  715. {}
  716.  
  717. void pdr2s(Scoord x, Scoord y)
  718. {}
  719.  
  720. void polf2s(long n, const Scoord parray[][2])
  721. {}
  722.  
  723. void polfs(long n, const Scoord parray[][3])
  724. {}
  725.  
  726. void poly2s(long n, const Scoord parray[][2])
  727. {}
  728.  
  729. void polys(long n, const Scoord parray[][3])
  730. {}
  731.  
  732. void pmv(Coord x, Coord y, Coord z)
  733. {}
  734.  
  735. void pmv2(Coord x, Coord y)
  736. {}
  737.  
  738. void pmvi(Icoord x, Icoord y, Icoord z)
  739. {}
  740.  
  741. void pmv2i(Icoord x, Icoord y)
  742. {}
  743.  
  744. void pmvs(Scoord x, Scoord y, Scoord z)
  745. {}
  746.  
  747. void pmv2s(Scoord x, Scoord y)
  748. {}
  749.  
  750. void pnt2s(Scoord x, Scoord y)
  751. {}
  752.  
  753. void pnts(Scoord x, Scoord y, Scoord z)
  754. {}
  755.  
  756. void popname(void)
  757. {}
  758.  
  759. void pushname(short name)
  760. {}
  761.  
  762. void rdr(Coord dx, Coord dy, Coord dz)
  763. {}
  764.  
  765. void rdr2(Coord dx, Coord dy)
  766. {}
  767.  
  768. void rdri(Icoord dx, Icoord dy, Icoord dz)
  769. {}
  770.  
  771. void rdr2i(Icoord dx, Icoord dy)
  772. {}
  773.  
  774. void rdrs(Scoord dx, Scoord dy, Scoord dz)
  775. {}
  776.  
  777. void rdr2s(Scoord dx, Scoord dy)
  778. {}
  779.  
  780. void rectcopy(Screencoord x1, Screencoord y1, Screencoord x2, Screencoord y2, Screencoord newx, Screencoord newy)
  781. {}
  782.  
  783. void rmv(Coord dx, Coord dy, Coord dz)
  784. {}
  785.  
  786. void rmv2(Coord dx, Coord dy)
  787. {}
  788.  
  789. void rmvi(Icoord dx, Icoord dy, Icoord dz)
  790. {}
  791.  
  792. void rmv2i(Icoord dx, Icoord dy)
  793. {}
  794.  
  795. void rmvs(Scoord dx, Scoord dy, Scoord dz)
  796. {}
  797.  
  798. void rmv2s(Scoord dx, Scoord dy)
  799. {}
  800.  
  801. void rpdr(Coord dx, Coord dy, Coord dz)
  802. {}
  803.  
  804. void rpdr2(Coord dx, Coord dy)
  805. {}
  806.  
  807. void rpdri(Icoord dx, Icoord dy, Icoord dz)
  808. {}
  809.  
  810. void rpdr2i(Icoord dx, Icoord dy)
  811. {}
  812.  
  813. void rpdrs(Scoord dx, Scoord dy, Scoord dz)
  814. {}
  815.  
  816. void rpdr2s(Scoord dx, Scoord dy)
  817. {}
  818.  
  819. void rpmv(Coord dx, Coord dy, Coord dz)
  820. {}
  821.  
  822. void rpmv2(Coord dx, Coord dy)
  823. {}
  824.  
  825. void rpmvi(Icoord dx, Icoord dy, Icoord dz)
  826. {}
  827.  
  828. void rpmv2i(Icoord dx, Icoord dy)
  829. {}
  830.  
  831. void rpmvs(Scoord dx, Scoord dy, Scoord dz)
  832. {}
  833.  
  834. void rpmv2s(Scoord dx, Scoord dy)
  835. {}
  836.  
  837. void setdblights(unsigned long mask)
  838. {}
  839.  
  840. void setmonitor(short montype)
  841. {}
  842.  
  843. void setshade(Colorindex shade)
  844. {}
  845.  
  846. void shaderange(Colorindex lowindex, Colorindex highindex, Screencoord z1, Screencoord z2)
  847. {}
  848.  
  849. void spclos(void)
  850. {}
  851.  
  852. void splf(long n, const Coord parray[][3], const Colorindex iarray[])
  853. {}
  854.  
  855. void splf2(long n, const Coord parray[][2], const Colorindex iarray[])
  856. {}
  857.  
  858. void splfi(long n, const Icoord parray[][3], const Colorindex iarray[])
  859. {}
  860.  
  861. void splf2i(long n, const Icoord parray[][2], const Colorindex iarray[])
  862. {}
  863.  
  864. void splfs(long n, const Scoord parray[][3], const Colorindex iarray[])
  865. {}
  866.  
  867. void splf2s(long n, const Scoord parray[][2], const Colorindex iarray[])
  868. {}
  869.  
  870. void xfpt(Coord x, Coord y, Coord z)
  871. {}
  872.  
  873. void xfpti(Icoord x, Icoord y, Icoord z)
  874. {}
  875.  
  876. void xfpts(Scoord x, Scoord y, Scoord z)
  877. {}
  878.  
  879. void xfpt2(Coord x, Coord y)
  880. {}
  881.  
  882. void xfpt2i(Icoord x, Icoord y)
  883. {}
  884.  
  885. void xfpt2s(Scoord x, Scoord y)
  886. {}
  887.  
  888. void xfpt4(Coord x, Coord y, Coord z, Coord w)
  889. {}
  890.  
  891. void xfpt4i(Icoord x, Icoord y, Icoord z, Icoord w)
  892. {}
  893.  
  894. void xfpt4s(Scoord x, Scoord y, Scoord z, Scoord w)
  895. {}
  896.  
  897. void zbuffer(Boolean bool)
  898. {}
  899.  
  900. void defpattern(short n, short size, const unsigned short mask[])
  901. {}
  902.  
  903. long getpattern(void)
  904. {
  905.     return (long)0;
  906. }
  907.  
  908. void setpattern(short index)
  909. {}
  910.  
  911. void objinsert(Tag t)
  912. {}
  913.  
  914. void objdelete(Tag tag1, Tag tag2)
  915. {}
  916.  
  917. void objreplace(Tag t)
  918. {}
  919.  
  920. void zclear(void)
  921. {}
  922.  
  923. void curorigin(short n, short xorigin, short yorigin)
  924. {}
  925.  
  926. void patchcurves(long ucurves, long vcurves)
  927. {}
  928.  
  929. void dbtext(char str[8])
  930. {}
  931.  
  932. void backface(Boolean b)
  933. {}
  934.  
  935. void cyclemap(short duration, short map, short nextmap)
  936. {}
  937.  
  938. void minsize(long x, long y)
  939. {}
  940.  
  941. void maxsize(long x, long y)
  942. {}
  943.  
  944. void keepaspect(long x, long y)
  945. {}
  946.  
  947. void prefsize(long x, long y)
  948. {}
  949.  
  950. void stepunit(long xunit, long yunit)
  951. {}
  952.  
  953. void fudge(long xfudge, long yfudge)
  954. {}
  955.  
  956. void prefposition(long x1, long x2, long y1, long y2)
  957. {}
  958.  
  959. void getport(String arg)
  960. {}
  961.  
  962. void callfunc(__PFV_ fp, long nargs, ...)
  963. {}
  964.  
  965. void getsize(long *x, long *y)
  966. {}
  967.  
  968. void getorigin(long *x, long *y)
  969. {}
  970.  
  971. void screenspace(void)
  972. {}
  973.  
  974. void reshapeviewport(void)
  975. {}
  976.  
  977. long winopen(String name)
  978. {
  979.     return (long)0;
  980. }
  981.  
  982. void winclose(long wid)
  983. {}
  984.  
  985. void winset(long wid)
  986. {}
  987.  
  988. long winget(void)
  989. {
  990.     return (long)0;
  991. }
  992.  
  993. void winpush(void)
  994. {}
  995.  
  996. void winpop(void)
  997. {}
  998.  
  999. long winattach(void)
  1000. {
  1001.     return (long)0;
  1002. }
  1003.  
  1004. void winmove(long orgx, long orgy)
  1005. {}
  1006.  
  1007. void winposition(long x1, long x2, long y1, long y2)
  1008. {}
  1009.  
  1010. void wintitle(String name)
  1011. {}
  1012.  
  1013. void rects(Scoord x1, Scoord y1, Scoord x2, Scoord y2)
  1014. {}
  1015.  
  1016. void rectfs(Scoord x1, Scoord y1, Scoord x2, Scoord y2)
  1017. {}
  1018.  
  1019. void foreground(void)
  1020. {}
  1021.  
  1022. void getdev(long n, const Device devs[], short vals[])
  1023. {}
  1024.  
  1025. Boolean ismex(void)
  1026. {
  1027.     return (Boolean)0;
  1028. }
  1029.  
  1030. void rcrv(const Coord geom[4][4])
  1031. {}
  1032.  
  1033. void rcrvn(long n, const Coord geom[][4])
  1034. {}
  1035.  
  1036. void rpatch(const Matrix geomx, const Matrix geomy, const Matrix geomz, const Matrix geomw)
  1037. {}
  1038.  
  1039. long getothermonitor(void)
  1040. {
  1041.     return (long)0;
  1042. }
  1043.  
  1044. void blanktime(long n)
  1045. {}
  1046.  
  1047. Boolean isqueued(Device arg)
  1048. {
  1049.     return (Boolean)0;
  1050. }
  1051.  
  1052. void rot(float angle, char axis)
  1053. {}
  1054.  
  1055. void addtopup(long pup, String str, ...)
  1056. {}
  1057.  
  1058. long dopup(long pup)
  1059. {
  1060.     return (long)0;
  1061. }
  1062.  
  1063. void freepup(long pup)
  1064. {}
  1065.  
  1066. long newpup(void)
  1067. {
  1068.     return (long)0;
  1069. }
  1070.  
  1071. void fullscrn(void)
  1072. {}
  1073.  
  1074. void endfullscrn(void)
  1075. {}
  1076.  
  1077. long getshade(void)
  1078. {
  1079.     return (long)0;
  1080. }
  1081.  
  1082. void winconstraints(void)
  1083. {}
  1084.  
  1085. void noport(void)
  1086. {}
  1087.  
  1088. void noborder(void)
  1089. {}
  1090.  
  1091. void imakebackground(void)
  1092. {}
  1093.  
  1094. void RGBrange(short rmin, short gmin, short bmin, short rmax, short gmax, short bmax, Screencoord zmin, Screencoord zmax)
  1095. {}
  1096.  
  1097. void cmode(void)
  1098. {}
  1099.  
  1100. void concave(Boolean b)
  1101. {}
  1102.  
  1103. void curstype(long typ)
  1104. {}
  1105.  
  1106. void drawmode(long mode)
  1107. {}
  1108.  
  1109. long getdrawmode(void)
  1110. {
  1111.     return (long)0;
  1112. }
  1113.  
  1114. void gammaramp(const short r[256], const short g[256], const short b[256])
  1115. {}
  1116.  
  1117. void shademodel(long mode)
  1118. {}
  1119.  
  1120. void overlay(long planes)
  1121. {}
  1122.  
  1123. void underlay(long planes)
  1124. {}
  1125.  
  1126. long getvideo(long reg)
  1127. {
  1128.     return (long)0;
  1129. }
  1130.  
  1131. void setvideo(long reg, long value)
  1132. {}
  1133.  
  1134. long defpup(String str, ...)
  1135. {
  1136.     return (long)0;
  1137. }
  1138.  
  1139. long getsm(void)
  1140. {
  1141.     return (long)0;
  1142. }
  1143.  
  1144. long getbackface(void)
  1145. {
  1146.     return (long)0;
  1147. }
  1148.  
  1149. long getdescender(void)
  1150. {
  1151.     return (long)0;
  1152. }
  1153.  
  1154. long getmmode(void)
  1155. {
  1156.     return (long)0;
  1157. }
  1158.  
  1159. void lmbind(short target, short indx)
  1160. {}
  1161.  
  1162. void lmdef(short deftype, short indx, short np, const float proparray[])
  1163. {}
  1164.  
  1165. void mmode(short m)
  1166. {}
  1167.  
  1168. void normal(const Coord fa[3])
  1169. {}
  1170.  
  1171. void bgnclosedline(void)
  1172. {}
  1173.  
  1174. void bgnline(void)
  1175. {}
  1176.  
  1177. void bgnpoint(void)
  1178. {}
  1179.  
  1180. void bgnpolygon(void)
  1181. {}
  1182.  
  1183. void bgntmesh(void)
  1184. {}
  1185.  
  1186. void blendfunction(long sfactor, long dfactor)
  1187. {}
  1188.  
  1189. void c3f(const float vp[3])
  1190. {}
  1191.  
  1192. void c3i(const long vp[3])
  1193. {}
  1194.  
  1195. void c3s(const short vp[3])
  1196. {}
  1197.  
  1198. void c4f(const float vp[4])
  1199. {}
  1200.  
  1201. void c4i(const long vp[4])
  1202. {}
  1203.  
  1204. void c4s(const short vp[4])
  1205. {}
  1206.  
  1207. void cpack(unsigned long abgr)
  1208. {}
  1209.  
  1210. void czclear(unsigned long cval, long zval)
  1211. {}
  1212.  
  1213. void endclosedline(void)
  1214. {}
  1215.  
  1216. void endline(void)
  1217. {}
  1218.  
  1219. void endpoint(void)
  1220. {}
  1221.  
  1222. void endpolygon(void)
  1223. {}
  1224.  
  1225. void endtmesh(void)
  1226. {}
  1227.  
  1228. void glcompat(long mode, long value)
  1229. {}
  1230.  
  1231. void lRGBrange(short rmin, short gmin, short bmin, short rmax, short gmax, short bmax, long zmin, long zmax)
  1232. {}
  1233.  
  1234. void lsetdepth(long zmin, long zmax)
  1235. {}
  1236.  
  1237. void lshaderange(Colorindex imin, Colorindex imax, long zmin, long zmax)
  1238. {}
  1239.  
  1240. long lrectread(Screencoord x1, Screencoord y1, Screencoord x2, Screencoord y2, unsigned long pixels[])
  1241. {
  1242.     return (long)0;
  1243. }
  1244.  
  1245. void lrectwrite(Screencoord x1, Screencoord y1, Screencoord x2, Screencoord y2, const unsigned long parray[])
  1246. {}
  1247.  
  1248. void n3f(const float v[3])
  1249. {}
  1250.  
  1251. void readsource(long mode)
  1252. {}
  1253.  
  1254. long rectread(Screencoord x1, Screencoord y1, Screencoord x2, Screencoord y2, Colorindex pixels[])
  1255. {
  1256.     return (long)0;
  1257. }
  1258.  
  1259. void rectwrite(Screencoord x1, Screencoord y1, Screencoord x2, Screencoord y2, const Colorindex parray[])
  1260. {}
  1261.  
  1262. void rectzoom(float xfactor, float yfactor)
  1263. {}
  1264.  
  1265. void smoothline(long mode)
  1266. {}
  1267.  
  1268. void swaptmesh(void)
  1269. {}
  1270.  
  1271. void v2d(const double v[2])
  1272. {}
  1273.  
  1274. void v2f(const float v[2])
  1275. {}
  1276.  
  1277. void v2i(const long v[2])
  1278. {}
  1279.  
  1280. void v2s(const short v[2])
  1281. {}
  1282.  
  1283. void v3d(const double v[3])
  1284. {}
  1285.  
  1286. void v3f(const float v[3])
  1287. {}
  1288.  
  1289. void v3i(const long v[3])
  1290. {}
  1291.  
  1292. void v3s(const short v[3])
  1293. {}
  1294.  
  1295. void v4d(const double v[4])
  1296. {}
  1297.  
  1298. void v4f(const float v[4])
  1299. {}
  1300.  
  1301. void v4i(const long v[4])
  1302. {}
  1303.  
  1304. void v4s(const short v[4])
  1305. {}
  1306.  
  1307. void wmpack(unsigned long abgr)
  1308. {}
  1309.  
  1310. void zdraw(Boolean flag)
  1311. {}
  1312.  
  1313. void zfunction(long func)
  1314. {}
  1315.  
  1316. void zsource(long zsrc)
  1317. {}
  1318.  
  1319. void zwritemask(unsigned long mask)
  1320. {}
  1321.  
  1322. long windepth(long wid)
  1323. {
  1324.     return (long)0;
  1325. }
  1326.  
  1327. void iconsize(long x, long y)
  1328. {}
  1329.  
  1330. void icontitle(String name)
  1331. {}
  1332.  
  1333. long swinopen(long wid)
  1334. {
  1335.     return (long)0;
  1336. }
  1337.  
  1338. long dglopen(String svname, long gctype)
  1339. {
  1340.     return (long)0;
  1341. }
  1342.  
  1343. void dglclose(long sid)
  1344. {}
  1345.  
  1346. void pntsmooth(unsigned long mode)
  1347. {}
  1348.  
  1349. void linesmooth(unsigned long mode)
  1350. {}
  1351.  
  1352. void subpixel(Boolean flag)
  1353. {}
  1354.  
  1355. void sbox(Coord x1, Coord y1, Coord x2, Coord y2)
  1356. {}
  1357.  
  1358. void sboxf(Coord x1, Coord y1, Coord x2, Coord y2)
  1359. {}
  1360.  
  1361. void sboxfi(Icoord x1, Icoord y1, Icoord x2, Icoord y2)
  1362. {}
  1363.  
  1364. void sboxi(Icoord x1, Icoord y1, Icoord x2, Icoord y2)
  1365. {}
  1366.  
  1367. void sboxs(Scoord x1, Scoord y1, Scoord x2, Scoord y2)
  1368. {}
  1369.  
  1370. void sboxfs(Scoord x1, Scoord y1, Scoord x2, Scoord y2)
  1371. {}
  1372.  
  1373. void bgnsurface(void)
  1374. {}
  1375.  
  1376. void endsurface(void)
  1377. {}
  1378.  
  1379. void bgntrim(void)
  1380. {}
  1381.  
  1382. void endtrim(void)
  1383. {}
  1384.  
  1385. void nurbssurface(long sknot_count, const double s_knot[], long tknot_count, const double t_knot[], long s_byte_size, long t_byte_size, const double ctlarray[], long s_order, long t_order, long typ)
  1386. {}
  1387.  
  1388. void nurbscurve(long knot_count, const double knot_list[], long byte_size, const double ctlarray[], long order, long typ)
  1389. {}
  1390.  
  1391. void pwlcurve(long cont, const double data_array[], long byte_size, long typ)
  1392. {}
  1393.  
  1394. void setnurbsproperty(long property, float value)
  1395. {}
  1396.  
  1397. void getnurbsproperty(long property, float *value)
  1398. {}
  1399.  
  1400. void lmcolor(long mode)
  1401. {}
  1402.  
  1403. void videocmd(long cmd)
  1404. {}
  1405.  
  1406. void logicop(long opcode)
  1407. {}
  1408.  
  1409. void colorf(float c)
  1410. {}
  1411.  
  1412. void setpup(long pup, long menuindex, unsigned long mode)
  1413. {}
  1414.  
  1415. long getgdesc(long inquiry)
  1416. {
  1417.     return (long)0;
  1418. }
  1419.  
  1420. void frontface(Boolean b)
  1421. {}
  1422.  
  1423. long scrnselect(long gsnr)
  1424. {
  1425.     return (long)0;
  1426. }
  1427.  
  1428. long getwscrn(void)
  1429. {
  1430.     return (long)0;
  1431. }
  1432.  
  1433. long scrnattach(long gsnr)
  1434. {
  1435.     return (long)0;
  1436. }
  1437.  
  1438. void pupmode(void)
  1439. {}
  1440.  
  1441. void endpupmode(void)
  1442. {}
  1443.  
  1444. long qcontrol(long cmd, long icnt, const short idata[], long ocnt, short odata[])
  1445. {
  1446.     return (long)0;
  1447. }
  1448.  
  1449. long qgetfd(void)
  1450. {
  1451.     return (long)0;
  1452. }
  1453.  
  1454. void bgnqstrip(void)
  1455. {}
  1456.  
  1457. void endqstrip(void)
  1458. {}
  1459.  
  1460. void nmode(long mode)
  1461. {}
  1462.  
  1463. void t2f(const float v[2])
  1464. {}
  1465.  
  1466. void t2d(const double v[2])
  1467. {}
  1468.  
  1469. void t2i(const long v[2])
  1470. {}
  1471.  
  1472. void t2s(const short v[2])
  1473. {}
  1474.  
  1475. void sclear(unsigned long sval)
  1476. {}
  1477.  
  1478. void acbuf(long op, float value)
  1479. {}
  1480.  
  1481. void acsize(long planes)
  1482. {}
  1483.  
  1484. void clipplane(long index, long mode, const float params[])
  1485. {}
  1486.  
  1487. void fogvertex(long mode, const float params[32])
  1488. {}
  1489.  
  1490. void getscrbox(long *left, long *right, long *bottom, long *top)
  1491. {}
  1492.  
  1493. void scrbox(long arg)
  1494. {}
  1495.  
  1496. void stensize(long planes)
  1497. {}
  1498.  
  1499. void stencil(long enable, unsigned long ref, long func, unsigned long mask, long fail, long pass, long zpass)
  1500. {}
  1501.  
  1502. void swritemask(unsigned long mask)
  1503. {}
  1504.  
  1505. void pixmode(long mode, long value)
  1506. {}
  1507.  
  1508. void polymode(long mode)
  1509. {}
  1510.  
  1511. void afunction(long ref, long func)
  1512. {}
  1513.  
  1514. void tevbind(long target, long index)
  1515. {}
  1516.  
  1517. void texbind(long target, long index)
  1518. {}
  1519.  
  1520. void mswapbuffers(long fbuf)
  1521. {}
  1522.  
  1523. void polysmooth(long mode)
  1524. {}
  1525.  
  1526. void scrsubdivide(long mode, const float params[])
  1527. {}
  1528.  
  1529. void tevdef(long index, long np, const float props[])
  1530. {}
  1531.  
  1532. void texdef2d(long n, long nc, long width, long height, const unsigned long image[], long np, const float param[])
  1533. {}
  1534.  
  1535. void texgen(long coord, long mode, const float params[])
  1536. {}
  1537.  
  1538. void linewidthf(float n)
  1539. {}
  1540.  
  1541. void pntsize(short n)
  1542. {}
  1543.  
  1544. void pntsizef(float n)
  1545. {}
  1546.  
  1547. long readdisplay(Screencoord x1, Screencoord y1, Screencoord x2, Screencoord y2, unsigned long pixels[], unsigned long hints)
  1548. {
  1549.     return (long)0;
  1550. }
  1551.  
  1552. void bgncurve(void)
  1553. {}
  1554.  
  1555. void endcurve(void)
  1556. {}
  1557.  
  1558. void pixmodef(long mode, float value)
  1559. {}
  1560.  
  1561. long GLXwinset(void *xDisplay, unsigned long xWindow)
  1562. {
  1563.     return (long)0;
  1564. }
  1565.  
  1566. GLXconfig * GLXgetconfig(void *xDisplay, long xScreen, GLXconfig * template)
  1567. {
  1568.     return (GLXconfig *)0;
  1569. }
  1570.  
  1571. long GLXlink(void *xDisplay, GLXconfig * config)
  1572. {
  1573.     return (long)0;
  1574. }
  1575.  
  1576. long GLXunlink(void *xDisplay, unsigned long xWindow)
  1577. {
  1578.     return (long)0;
  1579. }
  1580.  
  1581. void dither(long ditmode)
  1582. {}
  1583.  
  1584. void deflfont(short n, short nc, const Lfontchar chars[], long nr, const unsigned short raster[])
  1585. {}
  1586.  
  1587. void lcharstr(long typ, Lstring str)
  1588. {}
  1589.  
  1590. long lstrwidth(long typ, Lstring str)
  1591. {
  1592.     return (long)0;
  1593. }
  1594.  
  1595. void t3f(const float v[3])
  1596. {}
  1597.  
  1598. void t3d(const double v[3])
  1599. {}
  1600.  
  1601. void t3i(const long v[3])
  1602. {}
  1603.  
  1604. void t3s(const short v[3])
  1605. {}
  1606.  
  1607. void t4f(const float v[4])
  1608. {}
  1609.  
  1610. void t4d(const double v[4])
  1611. {}
  1612.  
  1613. void t4i(const long v[4])
  1614. {}
  1615.  
  1616. void t4s(const short v[4])
  1617. {}
  1618.  
  1619. void mssize(long samples, long zsize, long ssize)
  1620. {}
  1621.  
  1622. void mssample(long mode)
  1623. {}
  1624.  
  1625. void texdef3d(long n, long nc, long width, long height, long depth, const unsigned long image[], long np, const float param[])
  1626. {}
  1627.  
  1628. void monobuffer(void)
  1629. {}
  1630.  
  1631. void stereobuffer(void)
  1632. {}
  1633.  
  1634. void leftbuffer(Boolean enable)
  1635. {}
  1636.  
  1637. void rightbuffer(Boolean enable)
  1638. {}
  1639.  
  1640. void zbsize(long planes)
  1641. {}
  1642.  
  1643. void blendcolor(float r, float g, float b, float a)
  1644. {}
  1645.  
  1646. void msalpha(long mode)
  1647. {}
  1648.  
  1649. void msmask(float mask, Boolean flag)
  1650. {}
  1651.  
  1652. void mspattern(long pattern)
  1653. {}
  1654.  
  1655. void multisample(Boolean enable)
  1656. {}
  1657.  
  1658. long getgconfig(long buffer)
  1659. {
  1660.     return (long)0;
  1661. }
  1662.  
  1663. void hgram(unsigned long a, unsigned long b)
  1664. {}
  1665.  
  1666. void minmax(unsigned long a, unsigned long b)
  1667. {}
  1668.  
  1669. void pixeltransfer(long a, float b)
  1670. {}
  1671.  
  1672. Boolean getmultisample(void)
  1673. {
  1674.     return (Boolean)0;
  1675. }
  1676.  
  1677. void tlutdef(long index, long nc, long len, const unsigned long table[], long np, const float props[])
  1678. {}
  1679.  
  1680. void tlutbind(long target, long index)
  1681. {}
  1682.  
  1683. void subtexload(long target, long index, float l, float r, float b, float t, long nt, const unsigned long texels[], unsigned long flags)
  1684. {}
  1685.  
  1686. void convolve(long convop, long border, long xksize, long yksize, const float kernel[], float bias)
  1687. {}
  1688.  
  1689. void ildraw(unsigned long buffer)
  1690. {}
  1691.  
  1692. long ilbuffer(unsigned long buffers)
  1693. {
  1694.     return (long)0;
  1695. }
  1696.  
  1697. void displacepolygon(float scalefactor)
  1698. {}
  1699.  
  1700. void RGBsize(unsigned long mode)
  1701. {}
  1702.  
  1703. void fbsubtexload(long src_x, long src_y, long target, long index, float l, float r, float b, float t, unsigned long flags)
  1704. {}
  1705.  
  1706. void readcomponent(long mode)
  1707. {}
  1708.  
  1709. void gethgram(unsigned long parray[16384])
  1710. {}
  1711.  
  1712. void getminmax(float parray[8])
  1713. {}
  1714.  
  1715. long istexloaded(long target, long id)
  1716. {
  1717.     return (long)0;
  1718. }
  1719.  
  1720. void pixelmap(long map, long size, unsigned short parray[16384])
  1721. {}
  1722.  
  1723.  
  1724.